import { TranslateService } from '@ngx-translate/core';

export default function addRuleNodeCoreLocaleEnglish(translate: TranslateService) {

    const enUS = {
      tb: {
        rulenode: {
          id: 'Id',
          'additional-info': 'Additional Info',
          'advanced-settings': 'Advanced settings',
          'create-entity-if-not-exists': 'Create new entity if it doesn\'t exist',
          'create-entity-if-not-exists-hint': 'If enabled, a new entity with specified parameters will be created unless it already exists. Existing entities will be used as is for relation.',
          'select-device-connectivity-event': 'Select device connectivity event',
          'entity-name-pattern': 'Name pattern',
          'device-name-pattern': 'Device name',
          'asset-name-pattern': 'Asset name',
          'entity-view-name-pattern': 'Entity view name',
          'customer-title-pattern': 'Customer title',
          'dashboard-name-pattern': 'Dashboard title',
          'user-name-pattern': 'User email',
          'edge-name-pattern': 'Edge name',
          'entity-name-pattern-required': 'Name pattern is required',
          'entity-name-pattern-hint': 'Name pattern field support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'copy-message-type': 'Copy message type',
          'entity-type-pattern': 'Type pattern',
          'entity-type-pattern-required': 'Type pattern is required',
          'message-type-value': 'Message type value',
          'message-type-value-required': 'Message type value is required',
          'message-type-value-max-length': 'Message type value should be less than 256',
          'output-message-type': 'Output message type',
          'entity-cache-expiration': 'Entities cache expiration time (sec)',
          'entity-cache-expiration-hint':
            'Specifies maximum time interval allowed to store found entity records. 0 value means that records will never expire.',
          'entity-cache-expiration-required': 'Entities cache expiration time is required.',
          'entity-cache-expiration-range': 'Entities cache expiration time should be greater than or equal to 0.',
          'customer-name-pattern': 'Customer title',
          'customer-name-pattern-required': 'Customer title is required',
          'customer-name-pattern-hint': 'Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'create-customer-if-not-exists': 'Create new customer if it doesn\'t exist',
          'unassign-from-customer': 'Unassign from specific customer if originator is dashboard',
          'unassign-from-customer-tooltip': 'Only dashboards can be assigned to multiple customers at once. \nIf the message originator is a dashboard, you need to explicitly specify the customer\'s title to unassign from.',
          'customer-cache-expiration': 'Customers cache expiration time (sec)',
          'customer-cache-expiration-hint':
            'Specifies maximum time interval allowed to store found customer records. 0 value means that records will never expire.',
          'customer-cache-expiration-required': 'Customers cache expiration time is required.',
          'customer-cache-expiration-range': 'Customers cache expiration time should be greater than or equal to 0.',
          'interval-start': 'Interval start',
          'interval-end': 'Interval end',
          'time-unit': 'Time unit',
          'fetch-mode': 'Fetch mode',
          'order-by-timestamp': 'Order by timestamp',
          limit: 'Limit',
          'limit-hint': 'Min limit value is 2, max - 1000. If you want to fetch a single entry, select fetch mode \'First\' or \'Last\'.',
          'limit-required': 'Limit is required.',
          'limit-range': 'Limit should be in a range from 2 to 1000.',
          'time-unit-milliseconds': 'Milliseconds',
          'time-unit-seconds': 'Seconds',
          'time-unit-minutes': 'Minutes',
          'time-unit-hours': 'Hours',
          'time-unit-days': 'Days',
          'time-value-range': 'Allowing range from 1 to 2147483647.',
          'start-interval-value-required': 'Interval start is required.',
          'end-interval-value-required': 'Interval end is required.',
          filter: 'Filter',
          switch: 'Switch',
          'math-templatization-tooltip': 'This field support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'add-message-type': 'Add message type',
          'select-message-types-required': 'At least one message type should be selected.',
          'select-message-types': 'Select message types',
          'no-message-types-found': 'No message types found',
          'no-message-type-matching': '\'{{messageType}}\' not found.',
          'create-new-message-type': 'Create a new one.',
          'message-types-required': 'Message types are required.',
          'client-attributes': 'Client attributes',
          'shared-attributes': 'Shared attributes',
          'server-attributes': 'Server attributes',
          'attributes-keys': 'Attributes keys',
          'attributes-keys-required': 'Attributes keys are required',
          'attributes-scope': 'Attributes scope',
          'attributes-scope-value': 'Attributes scope value',
          'attributes-scope-value-copy': 'Copy attributes scope value',
          'attributes-scope-hint': 'Use the \'scope\' metadata key to dynamically set the attribute scope per message. If provided, this overrides the scope set in the configuration.',
          'notify-device': 'Force notification to the device',
          'send-attributes-updated-notification':'Send attributes updated notification',
          'send-attributes-updated-notification-hint': 'Send notification about updated attributes as a separate message to the rule engine queue.',
          'send-attributes-deleted-notification': 'Send attributes deleted notification',
          'send-attributes-deleted-notification-hint': 'Send notification about deleted attributes as a separate message to the rule engine queue.',
          'update-attributes-only-on-value-change': 'Save attributes only if the value changes',
          'update-attributes-only-on-value-change-hint': 'Updates the attributes on every incoming message disregarding if their value has changed. Increases API usage and reduces performance.',
          'update-attributes-only-on-value-change-hint-enabled': 'Updates the attributes only if their value has changed. If the value is not changed, no update to the attribute timestamp nor attribute change notification will be sent.',
          'fetch-credentials-to-metadata': 'Fetch credentials to metadata',
          'notify-device-on-update-hint': 'If enabled, force notification to the device about shared attributes update. If disabled, the notification behavior is controlled by the \'notifyDevice\' parameter from the incoming message metadata. To turn off the notification, the message metadata must contain the \'notifyDevice\' parameter set to \'false\'. Any other case will trigger the notification to the device.',
          'notify-device-on-delete-hint': 'If enabled, force notification to the device about shared attributes removal. If disabled, the notification behavior is controlled by the \'notifyDevice\' parameter from the incoming message metadata. To turn on the notification, the message metadata must contain the \'notifyDevice\' parameter set to \'true\'. In any other case, the notification will not be triggered to the device.',
          'latest-timeseries': 'Latest time series data keys',
          'timeseries-keys': 'Time series keys',
          'timeseries-keys-required': 'At least one time series key should be selected.',
          'add-timeseries-key': 'Add time series key',
          'add-message-field': 'Add message field',
          'relation-search-parameters': 'Relation search parameters',
          'relation-parameters': 'Relation parameters',
          'add-metadata-field': 'Add metadata field',
          'data-keys': 'Message field names',
          'copy-from': 'Copy from',
          'data-to-metadata': 'Data to metadata',
          'metadata-to-data': 'Metadata to data',
          'use-regular-expression-hint': 'Use regular expression to copy keys by pattern.\n\nTips & tricks:\nPress \'Enter\' to complete field name input.\nPress \'Backspace\' to delete field name. Multiple field names supported.',
          interval: 'Interval',
          'interval-required': 'Interval is required',
          'interval-hint': 'Deduplication interval in seconds.',
          'interval-min-error': 'Min allowed value is 1',
          'max-pending-msgs': 'Max pending messages',
          'max-pending-msgs-hint': 'Maximum number of messages that are stored in memory for each unique deduplication id.',
          'max-pending-msgs-required': 'Max pending messages is required',
          'max-pending-msgs-max-error': 'Max allowed value is 1000',
          'max-pending-msgs-min-error': 'Min allowed value is 1',
          'max-retries': 'Max retries',
          'max-retries-required': 'Max retries is required',
          'max-retries-hint': 'Maximum number of retries to push the deduplicated messages into the queue. 10 seconds delay is used between retries',
          'max-retries-max-error': 'Max allowed value is 100',
          'max-retries-min-error': 'Min allowed value is 0',
          strategy: 'Strategy',
          'strategy-required': 'Strategy is required',
          'strategy-all-hint': 'Return all messages that arrived during deduplication period as a single JSON array message. Where each element represents object with msg and metadata inner properties.',
          'strategy-first-hint': 'Return first message that arrived during deduplication period.',
          'strategy-last-hint': 'Return last message that arrived during deduplication period.',
          first: 'First',
          last: 'Last',
          all: 'All',
          'output-msg-type-hint': 'The message type of the deduplication result.',
          'queue-name-hint': 'The queue name where the deduplication result will be published.',
          keys: 'Keys',
          'keys-required': 'Keys are required',
          'rename-keys-in': 'Rename keys in',
          data: 'Data',
          message: 'Message',
          metadata: 'Metadata',
          'current-key-name': 'Current key name',

          'key-name-required': 'Key name is required',
          'new-key-name': 'New key name',
          'new-key-name-required': 'New key name is required',
          'metadata-keys': 'Metadata field names',
          'json-path-expression': 'JSON path expression',
          'json-path-expression-required': 'JSON path expression is required',
          'json-path-expression-hint': 'JSONPath specifies a path to an element or a set of elements in a JSON structure. \'$\' represents the root object or array.',
          'relations-query': 'Relations query',
          'device-relations-query': 'Device relations query',
          'max-relation-level': 'Max relation level',
          'max-relation-level-error': 'Value should be greater than 0 or unspecified.',
          'max-relation-level-invalid': 'Value should be an integer.',
          'relation-type': 'Relation type',
          'relation-type-pattern': 'Relation type pattern',
          'relation-type-pattern-required': 'Relation type pattern is required',
          'relation-types-list': 'Relation types to propagate',
          'relation-types-list-hint': 'If Propagate relation types are not selected, ' +
            'alarms will be propagated without filtering by relation type.',
          'unlimited-level': 'Unlimited level',
          'latest-telemetry': 'Latest telemetry',
          'add-telemetry-key': 'Add telemetry key',
          'delete-from': 'Delete from',
          'use-regular-expression-delete-hint': 'Use regular expression to delete keys by pattern.\n\nTips & tricks:\nPress \'Enter\' to complete field name input.\nPress \'Backspace\' to delete field name.\nMultiple field names supported.',
          'fetch-into': 'Fetch into',
          'attr-mapping': 'Attributes mapping:',
          'source-attribute': 'Source attribute key',
          'source-attribute-required': 'Source attribute key is required.',
          'source-telemetry': 'Source telemetry key',
          'source-telemetry-required': 'Source telemetry key is required.',
          'target-key': 'Target key',
          'target-key-required': 'Target key is required.',
          'attr-mapping-required': 'At least one mapping entry should be specified.',
          'fields-mapping': 'Fields mapping',
          'fields-mapping-hint': 'If the message field is set to $entityId, the message originator\'s id will be saved to the specified table column.',
          'relations-query-config-direction-suffix': 'originator',
          'profile-name': 'Profile name',
          'fetch-circle-parameter-info-from-metadata-hint': 'Metadata field \'{{perimeterKeyName}}\' should be defined in next format: {"latitude":48.196, "longitude":24.6532, "radius":100.0, "radiusUnit":"METER"}',
          'fetch-poligon-parameter-info-from-metadata-hint': 'Metadata field \'{{perimeterKeyName}}\' should be defined in next format: [[48.19736,24.65235],[48.19800,24.65060],...,[48.19849,24.65420]]',
          'short-templatization-tooltip': 'Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'fields-mapping-required': 'At least one field mapping should be specified.',
          'at-least-one-field-required': 'At least one input field must have a value(s) provided.',
          'originator-fields-sv-map-hint': 'Target key fields support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'sv-map-hint': 'Only target key fields support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'source-field': 'Source field',
          'source-field-required': 'Source field is required.',
          'originator-source': 'Originator source',
          'new-originator': 'New originator',
          'originator-customer': 'Customer',
          'originator-tenant': 'Tenant',
          'originator-related': 'Related entity',
          'originator-alarm-originator': 'Alarm Originator',
          'originator-entity': 'Entity by name pattern',
          'clone-message': 'Clone message',
          transform: 'Transform',
          'default-ttl': 'Default TTL in seconds',
          'default-ttl-required': 'Default TTL is required.',
          'default-ttl-hint': 'Rule node will fetch Time-to-Live (TTL) value from the message metadata. If no value is present, it defaults to the TTL specified in the configuration. If the value is set to 0, the TTL from the tenant profile configuration will be applied.',
          'default-ttl-zero-hint': 'TTL will not be applied if its value is set to 0.',
          'min-default-ttl-message': 'Only 0 minimum TTL is allowed.',
          'generation-parameters': 'Generation parameters',
          'message-count': 'Generated messages limit (0 - unlimited)',
          'message-count-required': 'Generated messages limit is required.',
          'min-message-count-message': 'Only 0 minimum message count is allowed.',
          'period-seconds': 'Period in seconds',
          'period-seconds-required': 'Period is required.',
          'generation-frequency-seconds': 'Generation frequency in seconds',
          'generation-frequency-required': 'Generation frequency is required.',
          'min-generation-frequency-message': 'Only 1 second minimum is allowed.',
          'script-lang-tbel': 'TBEL',
          'script-lang-js': 'JS',
          'use-metadata-period-in-seconds-patterns': 'Use period in seconds pattern',
          'use-metadata-period-in-seconds-patterns-hint':
            'If selected, rule node use period in seconds interval pattern from message metadata or data ' +
            'assuming that intervals are in the seconds.',
          'period-in-seconds-pattern': 'Period in seconds pattern',
          'period-in-seconds-pattern-required': 'Period in seconds pattern is required',
          'min-period-seconds-message': 'Only 1 second minimum period is allowed.',
          originator: 'Originator',
          'message-body': 'Message body',
          'message-metadata': 'Message metadata',
          generate: 'Generate',
          'current-rule-node': 'Current Rule Node',
          'current-tenant': 'Current Tenant',
          'generator-function': 'Generator function',
          'test-generator-function': 'Test generator function',
          generator: 'Generator',
          'test-filter-function': 'Test filter function',
          'test-switch-function': 'Test switch function',
          'test-transformer-function': 'Test transformer function',
          transformer: 'Transformer',
          'alarm-create-condition': 'Alarm create condition',
          'test-condition-function': 'Test condition function',
          'alarm-clear-condition': 'Alarm clear condition',
          'alarm-details-builder': 'Alarm details builder',
          'test-details-function': 'Test details function',
          'alarm-type': 'Alarm type',
          'select-entity-types': 'Select entity types',
          'alarm-type-required': 'Alarm type is required.',
          'alarm-severity': 'Alarm severity',
          'alarm-severity-required': 'Alarm severity is required',
          'alarm-severity-pattern': 'Alarm severity pattern',
          'alarm-status-filter': 'Alarm status filter',
          'alarm-status-list-empty': 'Alarm status list is empty',
          'no-alarm-status-matching': 'No alarm status matching were found.',
          propagate: 'Propagate alarm to related entities',
          'propagate-to-owner': 'Propagate alarm to entity owner (Customer or Tenant)',
          'propagate-to-tenant': 'Propagate alarm to Tenant',
          condition: 'Condition',
          details: 'Details',
          'to-string': 'To string',
          'test-to-string-function': 'Test to string function',
          'from-template': 'From',
          'from-template-required': 'From is required',
          'message-to-metadata': 'Message to metadata',
          'metadata-to-message': 'Metadata to message',
          'from-message': 'From message',
          'from-metadata': 'From metadata',
          'to-template': 'To',
          'to-template-required': 'To Template is required',
          'mail-address-list-template-hint':
            'Comma separated address list, use <code><span style="color: #000;">$&#123;</span>metadataKey<span style="color: #000;">' +
            '&#125;</span></code> for value from metadata, <code><span style="color: #000;">$[</span>messageKey' +
            '<span style="color: #000;">]</span></code> for value from message body',
          'cc-template': 'Cc',
          'bcc-template': 'Bcc',
          'subject-template': 'Subject',
          'subject-template-required': 'Subject Template is required',
          'body-template': 'Body',
          'body-template-required': 'Body Template is required',
          'dynamic-mail-body-type': 'Dynamic mail body type',
          'mail-body-type': 'Mail body type',
          'body-type-template': 'Body type template',
          'reply-routing-configuration': 'Reply Routing Configuration',
          'rpc-reply-routing-configuration-hint': 'These configuration parameters specify the metadata key names used to identify the service, session, and request for sending a reply back.',
          'reply-routing-configuration-hint': 'These configuration parameters specify the metadata key names used to identify the service and request for sending a reply back.',
          'request-id-metadata-attribute': 'Request Id',
          'service-id-metadata-attribute': 'Service Id',
          'session-id-metadata-attribute': 'Session Id',
          'timeout-sec': 'Timeout in seconds',
          'timeout-required': 'Timeout is required',
          'min-timeout-message': 'Only 0 minimum timeout value is allowed.',
          'endpoint-url-pattern': 'Endpoint URL pattern',
          'endpoint-url-pattern-required': 'Endpoint URL pattern is required',
          'request-method': 'Request method',
          'use-simple-client-http-factory': 'Use simple client HTTP factory',
          'ignore-request-body': 'Without request body',
          'parse-to-plain-text': 'Parse to plain text',
          'parse-to-plain-text-hint': 'If selected, request body message payload will be transformed from JSON string to plain text, e.g. msg = "Hello,\\t\\"world\\"" will be parsed to Hello, "world"',
          'read-timeout': 'Read timeout in millis',
          'read-timeout-hint': 'The value of 0 means an infinite timeout',
          'max-parallel-requests-count': 'Max number of parallel requests',
          'max-parallel-requests-count-hint': 'The value of 0 specifies no limit in parallel processing',
          'max-response-size': 'Max response size (in KB)',
          'max-response-size-hint': 'The maximum amount of memory allocated for buffering data when decoding or encoding HTTP messages, such as JSON or XML payloads',
          headers: 'Headers',
          'headers-hint': 'Use <code><span style="color: #000;">$&#123;</span>metadataKey<span style="color: #000;">&#125;</span></code> ' +
            'for value from metadata, <code><span style="color: #000;">$[</span>messageKey<span style="color: #000;">]</span></code> ' +
            'for value from message body in header/value fields',
          header: 'Header',
          'header-required': 'Header is required',
          value: 'Value',
          'value-required': 'Value is required',
          'topic-pattern': 'Topic pattern',
          'key-pattern': 'Key pattern',
          'key-pattern-hint': 'Optional. If a valid partition number is specified, it will be used when sending the record. ' +
                              'If no partition is specified, the key will be used instead. '+
                              'If neither is specified, a partition will be assigned in a round-robin fashion.',
          'topic-pattern-required': 'Topic pattern is required',
          topic: 'Topic',
          'topic-required': 'Topic is required',
          'bootstrap-servers': 'Bootstrap servers',
          'bootstrap-servers-required': 'Bootstrap servers value is required',
          'other-properties': 'Other properties',
          key: 'Key',
          'key-required': 'Key is required',
          retries: 'Automatically retry times if fails',
          'min-retries-message': 'Only 0 minimum retries is allowed.',
          'batch-size-bytes': 'Produces batch size in bytes',
          'min-batch-size-bytes-message': 'Only 0 minimum batch size is allowed.',
          'linger-ms': 'Time to buffer locally (ms)',
          'min-linger-ms-message': 'Only 0 ms minimum value is allowed.',
          'buffer-memory-bytes': 'Client buffer max size in bytes',
          'min-buffer-memory-message': 'Only 0 minimum buffer size is allowed.',
          'memory-buffer-size-range': 'Memory buffer size must be between 0 and {{max}} KB',
          acks: 'Number of acknowledgments',
          'key-serializer': 'Key serializer',
          'key-serializer-required': 'Key serializer is required',
          'value-serializer': 'Value serializer',
          'value-serializer-required': 'Value serializer is required',
          'topic-arn-pattern': 'Topic ARN pattern',
          'topic-arn-pattern-required': 'Topic ARN pattern is required',
          'aws-access-key-id': 'AWS Access Key ID',
          'aws-access-key-id-required': 'AWS Access Key ID is required',
          'aws-secret-access-key': 'AWS Secret Access Key',
          'aws-secret-access-key-required': 'AWS Secret Access Key is required',
          'aws-region': 'AWS Region',
          'aws-region-required': 'AWS Region is required',
          'exchange-name-pattern': 'Exchange name pattern',
          'routing-key-pattern': 'Routing key pattern',
          'message-properties': 'Message properties',
          host: 'Host',
          'host-required': 'Host is required',
          port: 'Port',
          'port-required': 'Port is required',
          'port-range': 'Port should be in a range from 1 to 65535.',
          'virtual-host': 'Virtual host',
          username: 'Username',
          password: 'Password',
          'automatic-recovery': 'Automatic recovery',
          'connection-timeout-ms': 'Connection timeout (ms)',
          'min-connection-timeout-ms-message': 'Only 0 ms minimum value is allowed.',
          'handshake-timeout-ms': 'Handshake timeout (ms)',
          'min-handshake-timeout-ms-message': 'Only 0 ms minimum value is allowed.',
          'client-properties': 'Client properties',
          'queue-url-pattern': 'Queue URL pattern',
          'queue-url-pattern-required': 'Queue URL pattern is required',
          'delay-seconds': 'Delay (seconds)',
          'min-delay-seconds-message': 'Only 0 seconds minimum value is allowed.',
          'max-delay-seconds-message': 'Only 900 seconds maximum value is allowed.',
          name: 'Name',
          'name-required': 'Name is required',
          'queue-type': 'Queue type',
          'sqs-queue-standard': 'Standard',
          'sqs-queue-fifo': 'FIFO',
          'gcp-project-id': 'GCP project ID',
          'gcp-project-id-required': 'GCP project ID is required',
          'gcp-service-account-key': 'GCP service account key file',
          'gcp-service-account-key-required': 'GCP service account key file is required',
          'pubsub-topic-name': 'Topic name',
          'pubsub-topic-name-required': 'Topic name is required',
          'message-attributes': 'Message attributes',
          'message-attributes-hint': 'Use <code><span style="color: #000;">$&#123;</span>metadataKey<span style="color: #000000;">&#125;</span></code> ' +
                        'for value from metadata, <code><span style="color: #000;">$[</span>messageKey<span style="color: #000;">]</span></code> ' +
                        'for value from message body in name/value fields',
          'connect-timeout': 'Connection timeout (sec)',
          'connect-timeout-required': 'Connection timeout is required.',
          'connect-timeout-range': 'Connection timeout should be in a range from 1 to 200.',
          'client-id': 'Client ID',
          'client-id-hint': 'Optional. Leave empty for auto-generated Client ID. Be careful when specifying the Client ID. ' +
              'Majority of the MQTT brokers will not allow multiple connections with the same Client ID. ' +
              'To connect to such brokers, your mqtt Client ID must be unique. ' +
              'When platform is running in a micro-services mode, the copy of rule node is launched in each micro-service. ' +
              'This will automatically lead to multiple mqtt clients with the same ID and may cause failures of the rule node. ' +
              'To avoid such failures enable "Add Service ID as suffix to Client ID" option below.',
          'append-client-id-suffix': 'Add Service ID as suffix to Client ID',
          'client-id-suffix-hint': 'Optional. Applied when "Client ID" specified explicitly. ' +
            'If selected then Service ID will be added to Client ID as a suffix. ' +
            'Helps to avoid failures when platform is running in a micro-services mode.',
          'device-id':'Device ID',
          'device-id-required':'Device ID is required.',
          'clean-session': 'Clean session',
          'enable-ssl': 'Enable SSL',
          credentials: 'Credentials',
          'credentials-type': 'Credentials type',
          'credentials-type-required': 'Credentials type is required.',
          'credentials-anonymous': 'Anonymous',
          'credentials-basic': 'Basic',
          'credentials-pem': 'PEM',
          'credentials-pem-hint': 'At least Server CA certificate file or a pair of Client certificate and Client private key files are required',
          'credentials-sas': 'Shared Access Signature',
          'sas-key': 'SAS Key',
          'sas-key-required': 'SAS Key is required.',
          hostname: 'Hostname',
          'hostname-required': 'Hostname is required.',
          'azure-ca-cert': 'CA certificate file',
          'username-required': 'Username is required.',
          'password-required': 'Password is required.',
          'ca-cert': 'Server CA certificate file',
          'private-key': 'Client private key file',
          cert: 'Client certificate file',
          'no-file': 'No file selected.',
          'drop-file': 'Drop a file or click to select a file to upload.',
          'private-key-password': 'Private key password',
          'use-system-smtp-settings': 'Use system SMTP settings',
          'use-metadata-dynamic-interval': 'Use dynamic interval',
          'metadata-dynamic-interval-hint': 'Interval start and end input fields support templatization. Note that the substituted template value should be set in milliseconds. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'use-metadata-interval-patterns-hint':
            'If selected, rule node use start and end interval patterns from message metadata or data ' +
            'assuming that intervals are in the milliseconds.',
          'use-message-alarm-data': 'Use message alarm data',
          'overwrite-alarm-details': 'Overwrite alarm details',
          'use-alarm-severity-pattern': 'Use alarm severity pattern',
          'check-all-keys': 'Check that all specified fields are present',
          'check-all-keys-hint': 'If selected, checks that all specified keys are present in the message data and metadata.',
          'check-relation-to-specific-entity': 'Check relation to specific entity',
          'check-relation-to-specific-entity-tooltip': 'If enabled, checks the presence of relation with a specific entity otherwise, checks the presence of relation with any entity. In both cases, relation lookup is based on configured direction and type.',
          'check-relation-hint': 'Checks existence of relation to specific entity or to any entity based on direction and relation type.',
          'delete-relation-with-specific-entity': 'Delete relation with specific entity',
          'delete-relation-with-specific-entity-hint': 'If enabled, will delete the relation with just one specific entity. Otherwise, the relation will be removed with all matching entities.',
          'delete-relation-hint':
            'Deletes relation from the originator of the incoming message to the specified ' +
            'entity or list of entities based on direction and type.',
          'remove-current-relations': 'Remove current relations',
          'remove-current-relations-hint':
            'Removes current relations from the originator of the incoming message based on direction and type.',
          'change-originator-to-related-entity': 'Change originator to related entity',
          'change-originator-to-related-entity-hint': 'Used to process submitted message as a message from another entity.',
          'start-interval': 'Interval start',
          'end-interval': 'Interval end',
          'start-interval-required': 'Interval start is required.',
          'end-interval-required': 'Interval end is required.',
          'smtp-protocol': 'Protocol',
          'smtp-host': 'SMTP host',
          'smtp-host-required': 'SMTP host is required.',
          'smtp-port': 'SMTP port',
          'smtp-port-required': 'You must supply a smtp port.',
          'smtp-port-range': 'SMTP port should be in a range from 1 to 65535.',
          'timeout-msec': 'Timeout ms',
          'min-timeout-msec-message': 'Only 0 ms minimum value is allowed.',
          'enter-username': 'Enter username',
          'enter-password': 'Enter password',
          'enable-tls': 'Enable TLS',
          'tls-version': 'TLS version',
          'enable-proxy': 'Enable proxy',
          'use-system-proxy-properties': 'Use system proxy properties',
          'proxy-host': 'Proxy host',
          'proxy-host-required': 'Proxy host is required.',
          'proxy-port': 'Proxy port',
          'proxy-port-required': 'Proxy port is required.',
          'proxy-port-range': 'Proxy port should be in a range from 1 to 65535.',
          'proxy-user': 'Proxy user',
          'proxy-password': 'Proxy password',
          'proxy-scheme': 'Proxy scheme',
          'numbers-to-template': 'Phone Numbers To Template',
          'numbers-to-template-required': 'Phone Numbers To Template is required',
          'numbers-to-template-hint': 'Comma separated Phone Numbers, use <code><span style="color: #000;">$&#123;</span>' +
            'metadataKey<span style="color: #000;">&#125;</span></code> for value from metadata, <code><span style="color: #000;">' +
            '$[</span>messageKey<span style="color: #000;">]</span></code> for value from message body',
          'sms-message-template': 'SMS message Template',
          'sms-message-template-required': 'SMS message Template is required',
          'use-system-sms-settings': 'Use system SMS provider settings',
          'min-period-0-seconds-message': 'Only 0 second minimum period is allowed.',
          'max-pending-messages': 'Maximum pending messages',
          'max-pending-messages-required': 'Maximum pending messages is required.',
          'max-pending-messages-range': 'Maximum pending messages should be in a range from 1 to 100000.',
          'originator-types-filter': 'Originator types filter',
          'interval-seconds': 'Interval in seconds',
          'interval-seconds-required': 'Interval is required.',
          'int-range': 'Value must not exceed the maximum integer limit (2147483648)',
          'min-interval-seconds-message': 'Only 1 second minimum interval is allowed.',
          'output-timeseries-key-prefix': 'Output time series key prefix',
          'output-timeseries-key-prefix-required': 'Output time series key prefix required.',
          'separator-hint': 'Press "Enter" to complete field input.',
          'select-details': 'Select details',
          'entity-details-id': 'Id',
          'entity-details-title': 'Title',
          'entity-details-country': 'Country',
          'entity-details-state': 'State',
          'entity-details-city': 'City',
          'entity-details-zip': 'Zip',
          'entity-details-address': 'Address',
          'entity-details-address2': 'Address2',
          'entity-details-additional_info': 'Additional Info',
          'entity-details-phone': 'Phone',
          'entity-details-email': 'Email',
          'email-sender': 'Email sender',
          'fields-to-check': 'Fields to check',
          'add-detail': 'Add detail',
          'check-all-keys-tooltip': 'If enabled, checks the presence of all fields listed in the message and metadata field names within the incoming message and its metadata.',
          'fields-to-check-hint': 'Press "Enter" to complete field name input. Multiple field names supported.',
          'entity-details-list-empty': 'At least one detail should be selected.',
          'alarm-status': 'Alarm status',
          'alarm-required': 'At least one alarm status should be selected.',
          'no-entity-details-matching': 'No entity details matching were found.',
          'custom-table-name': 'Custom table name',
          'custom-table-name-required': 'Table Name is required',
          'custom-table-hint': 'The table must be created in your Cassandra cluster and its name must start with the prefix \'cs_tb_\' to avoid the data insertion to the common TB tables. Enter the table name here without the \'cs_tb_\' prefix.',
          'message-field': 'Message field',
          'message-field-required': 'Message field is required.',
          'table-col': 'Table column',
          'table-col-required': 'Table column is required.',
          'latitude-field-name': 'Latitude field name',
          'longitude-field-name': 'Longitude field name',
          'latitude-field-name-required': 'Latitude field name is required.',
          'longitude-field-name-required': 'Longitude field name is required.',
          'fetch-perimeter-info-from-metadata': 'Fetch perimeter information from metadata',
          'fetch-perimeter-info-from-metadata-tooltip': 'If perimeter type is set to \'Polygon\' the value of metadata field \'{{perimeterKeyName}}\' will be set as perimeter definition without additional parsing of the value. Otherwise, if perimeter type is set to \'Circle\' the value of \'{{perimeterKeyName}}\' metadata field will be parsed to extract \'latitude\', \'longitude\',  \'radius\', \'radiusUnit\' fields that uses for circle perimeter definition.',
          'perimeter-key-name': 'Perimeter key name',
          'perimeter-key-name-hint': 'Metadata field name that includes perimeter information.',
          'perimeter-key-name-required': 'Perimeter key name is required.',
          'perimeter-circle': 'Circle',
          'perimeter-polygon': 'Polygon',
          'perimeter-type': 'Perimeter type',
          'circle-center-latitude': 'Center latitude',
          'circle-center-latitude-required': 'Center latitude is required.',
          'circle-center-longitude': 'Center longitude',
          'circle-center-longitude-required': 'Center longitude is required.',
          'range-unit-meter': 'Meter',
          'range-unit-kilometer': 'Kilometer',
          'range-unit-foot': 'Foot',
          'range-unit-mile': 'Mile',
          'range-unit-nautical-mile': 'Nautical mile',
          'range-units': 'Range units',
          'range-units-required': 'Range units is required.',
          range: 'Range',
          'range-required': 'Range is required.',
          'polygon-definition': 'Polygon definition',
          'polygon-definition-required': 'Polygon definition is required.',
          'polygon-definition-hint':
            'Use the following format for manual definition of polygon: [[lat1,lon1],[lat2,lon2], ... ,[latN,lonN]].',
          'min-inside-duration': 'Minimal inside duration',
          'min-inside-duration-value-required': 'Minimal inside duration is required',
          'min-inside-duration-time-unit': 'Minimal inside duration time unit',
          'min-outside-duration': 'Minimal outside duration',
          'min-outside-duration-value-required': 'Minimal outside duration is required',
          'min-outside-duration-time-unit': 'Minimal outside duration time unit',
          'tell-failure-if-absent': 'Tell Failure',
          'tell-failure-if-absent-hint': 'If at least one selected key doesn\'t exist the outbound message will report "Failure".',
          'get-latest-value-with-ts': 'Fetch timestamp for the latest telemetry values',
          'get-latest-value-with-ts-hint':
            'If selected, the latest telemetry values will also include timestamp, ' +
            'e.g: "temp": "&#123;"ts":1574329385897, "value":42&#125;"',
          'ignore-null-strings': 'Ignore null strings',
          'ignore-null-strings-hint': 'If selected rule node will ignore entity fields with empty value.',
          'add-metadata-key-values-as-kafka-headers': 'Add Message metadata key-value pairs to Kafka record headers',
          'add-metadata-key-values-as-kafka-headers-hint': 'If selected, key-value pairs from message metadata will be added to the outgoing records headers as byte arrays with predefined charset encoding.',
          'charset-encoding': 'Charset encoding',
          'charset-encoding-required': 'Charset encoding is required.',
          'charset-us-ascii': 'US-ASCII',
          'charset-iso-8859-1': 'ISO-8859-1',
          'charset-utf-8': 'UTF-8',
          'charset-utf-16be': 'UTF-16BE',
          'charset-utf-16le': 'UTF-16LE',
          'charset-utf-16': 'UTF-16',
          'select-queue-hint': 'The queue name can be selected from a drop-down list or add a custom name.',
          'device-profile-node-hint': 'Useful if you have duration or repeating conditions to ensure continuity of alarm state evaluation.',
          'persist-alarm-rules': 'Persist state of alarm rules',
          'persist-alarm-rules-hint': 'If enabled, the rule node will store the state of processing to the database.',
          'fetch-alarm-rules': 'Fetch state of alarm rules',
          'fetch-alarm-rules-hint': 'If enabled, the rule node will restore the state of processing on initialization and ensure that alarms are raised even after server restarts. Otherwise, the state will be restored when the first message from the device arrives.',
          'input-value-key': 'Input value key',
          'input-value-key-required': 'Input value key is required.',
          'output-value-key': 'Output value key',
          'output-value-key-required': 'Output value key is required.',
          'number-of-digits-after-floating-point': 'Number of digits after floating point',
          'number-of-digits-after-floating-point-range': 'Number of digits after floating point should be in a range from 0 to 15.',
          'failure-if-delta-negative': 'Tell Failure if delta is negative',
          'failure-if-delta-negative-tooltip': 'Rule node forces failure of message processing if delta value is negative.',
          'use-caching': 'Use caching',
          'use-caching-tooltip': 'Rule node will cache the value of "{{inputValueKey}}" that arrives from the incoming message to improve performance. Note that the cache will not be updated if you modify the "{{inputValueKey}}" value elsewhere.',
          'add-time-difference-between-readings': 'Add the time difference between "{{inputValueKey}}" readings',
          'add-time-difference-between-readings-tooltip': 'If enabled, the rule node will add the "{{periodValueKey}}" to the outbound message.',
          'period-value-key': 'Period value key',
          'period-value-key-required': 'Period value key is required.',
          'general-pattern-hint': 'Use ${metadataKey} for value from metadata, $[messageKey] for value from message body.',
          'alarm-severity-pattern-hint': 'Use <code><span style="color: #000;">$&#123;</span>metadataKey<span style="color: #000;">&#125;</span></code> ' +
            'for value from metadata, <code><span style="color: #000;">$[</span>messageKey<span style="color: #000;">]</span></code> ' +
            'for value from message body. Alarm severity should be system (CRITICAL, MAJOR etc.)',
          'output-node-name-hint': 'The <b>rule node name</b> corresponds to the <b>relation type</b> of the output message, and it is used to forward messages to other rule nodes in the caller rule chain.',
          'skip-latest-persistence': 'Skip latest persistence',
          'skip-latest-persistence-hint': 'Rule node will not update values for incoming keys for the latest time series data. Useful for highly loaded use-cases to decrease the pressure on the DB.',
          'use-server-ts': 'Use server ts',
          'use-server-ts-hint': 'Rule node will use the timestamp of message processing instead of the timestamp from the message. Useful for all sorts of sequential processing if you merge messages from multiple sources (devices, assets, etc).',
          'kv-map-pattern-hint': 'All input fields support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'kv-map-single-pattern-hint': 'Input field support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'shared-scope': 'Shared scope',
          'server-scope': 'Server scope',
          'client-scope': 'Client scope',
          'attribute-type': 'Attribute',
          'constant-type': 'Constant',
          'time-series-type': 'Time series',
          'message-body-type': 'Message',
          'message-metadata-type': 'Metadata',
          'argument-tile': 'Arguments',
          'no-arguments-prompt': 'No arguments configured',
          'result-title': 'Result',
          'functions-field-input': 'Functions',
          'no-option-found': 'No option found',
          'argument-source-field-input': 'Source',
          'argument-source-field-input-required': 'Argument source is required.',
          'argument-key-field-input': 'Key',
          'argument-key-field-input-required': 'Argument key is required.',
          'constant-value-field-input': 'Constant value',
          'constant-value-field-input-required': 'Constant value is required.',
          'attribute-scope-field-input': 'Attribute scope',
          'attribute-scope-field-input-required': 'Attribute scope os required.',
          'default-value-field-input': 'Default value',
          'type-field-input': 'Type',
          'type-field-input-required': 'Type is required.',
          'key-field-input': 'Key',
          'add-entity-type': 'Add entity type',
          'add-device-profile': 'Add device profile',
          'key-field-input-required': 'Key is required.',
          'number-floating-point-field-input': 'Number of digits after floating point',
          'number-floating-point-field-input-hint': 'Use <i>0</i> to convert result to integer',
          'add-to-message-field-input': 'Add to message',
          'add-to-metadata-field-input': 'Add to metadata',
          'custom-expression-field-input': 'Mathematical Expression',
          'custom-expression-field-input-required': 'Mathematical expression is required',
          'custom-expression-field-input-hint': 'Specify a mathematical expression to evaluate. Default expression demonstrates how to transform Fahrenheit to Celsius',
          'retained-message': 'Retained',
          'attributes-mapping': 'Attributes mapping',
          'latest-telemetry-mapping': 'Latest telemetry mapping',
          'add-mapped-attribute-to': 'Add mapped attributes to',
          'add-mapped-latest-telemetry-to': 'Add mapped latest telemetry to',
          'add-mapped-fields-to': 'Add mapped fields to',
          'add-selected-details-to': 'Add selected details to',
          'clear-selected-types': 'Clear selected types',
          'clear-selected-details': 'Clear selected details',
          'clear-selected-fields': 'Clear selected fields',
          'clear-selected-keys': 'Clear selected keys',
          'geofence-configuration': 'Geofence configuration',
          'coordinate-field-names': 'Coordinate field names',
          'coordinate-field-hint': 'Rule node tries to retrieve the specified fields from the message. If they are not present, it will look them up in the metadata.',
          'presence-monitoring-strategy':'Presence monitoring strategy',
          'presence-monitoring-strategy-on-first-message':'On first message',
          'presence-monitoring-strategy-on-each-message':'On each message',
          'presence-monitoring-strategy-on-first-message-hint':'Reports presence status \'Inside\' or \'Outside\' on the first message after the configured minimal duration has passed since previous presence status \'Entered\' or \'Left\' update.',
          'presence-monitoring-strategy-on-each-message-hint':'Reports presence status \'Inside\' or \'Outside\' on each message after presence status \'Entered\' or \'Left\' update.',
          'fetch-credentials-to': 'Fetch credentials to',
          'add-originator-attributes-to': 'Add originator attributes to',
          'originator-attributes': 'Originator attributes',
          'fetch-latest-telemetry-with-timestamp': 'Fetch latest telemetry with timestamp',
          'fetch-latest-telemetry-with-timestamp-tooltip': 'If selected, latest telemetry values will be added to the outbound metadata with timestamp, e.g: "{{latestTsKeyName}}": "{"ts":1574329385897, "value":42}"',
          'tell-failure': 'Tell failure if any of the attributes are missing',
          'tell-failure-tooltip': 'If at least one selected key doesn\'t exist the outbound message will report "Failure".',
          'created-time': 'Created time',
          'chip-help': 'Press \'Enter\' to complete {{inputName}} input. \nPress \'Backspace\' to delete {{inputName}}. \nMultiple values supported.',
          detail: 'detail',
          'field-name': 'field name',
          'device-profile': 'device profile',
          'entity-type': 'entity type',
          'message-type': 'message type',
          'timeseries-key': 'time series key',
          type: 'Type',
          'first-name': 'First name',
          'last-name': 'Last name',
          label: 'Label',
          'originator-fields-mapping': 'Originator fields mapping',
          'add-mapped-originator-fields-to': 'Add mapped originator fields to',
          fields: 'Fields',
          'skip-empty-fields': 'Skip empty fields',
          'skip-empty-fields-tooltip': 'Fields with empty values will not be added to the output message/output metadata.',
          'fetch-interval': 'Fetch interval',
          'fetch-strategy': 'Fetch strategy',
          'fetch-timeseries-from-to': 'Fetch time series from {{startInterval}} {{startIntervalTimeUnit}} ago to {{endInterval}} {{endIntervalTimeUnit}} ago.',
          'fetch-timeseries-from-to-invalid': 'Fetch time series invalid ("Interval start" should be less than "Interval end").',
          'use-metadata-dynamic-interval-tooltip': 'If selected, the rule node will use dynamic interval start and end based on the message and metadata patterns.',
          'all-mode-hint': 'If selected fetch mode "All" rule node will retrieve telemetry from the fetch interval with configurable query parameters.',
          'first-mode-hint': 'If selected fetch mode "First" rule node will retrieve the closest telemetry to the fetch interval\'s start.',
          'last-mode-hint': 'If selected fetch mode "Last" rule node will retrieve the closest telemetry to the fetch interval\'s end.',
          ascending: 'Ascending',
          descending: 'Descending',
          min: 'Min',
          max: 'Max',
          average: 'Average',
          sum: 'Sum',
          count: 'Count',
          none: 'None',
          'last-level-relation-tooltip': 'If selected, the rule node will search related entities only on the level set in the max relation level.',
          'last-level-device-relation-tooltip': 'If selected, the rule node will search related devices only on the level set in the max relation level.',
          'data-to-fetch': 'Data to fetch',
          'mapping-of-customers':'Mapping of customer\'s',
          'map-fields-required': 'All mapping fields are required.',
          attributes: 'Attributes',
          'related-device-attributes': 'Related device attributes',
          'add-selected-attributes-to': 'Add selected attributes to',
          'device-profiles': 'Device profiles',
          'mapping-of-tenant':'Mapping of tenant\'s',
          'add-attribute-key': 'Add attribute key',
          'message-template': 'Message template',
          'message-template-required': 'Message template is required',
          'use-system-slack-settings': 'Use system slack settings',
          'slack-api-token': 'Slack API token',
          'slack-api-token-required': 'Slack API token is required',
          'keys-mapping': 'keys mapping',
          'add-key': 'Add key',
          recipients: 'Recipients',
          'message-subject-and-content': 'Message subject and content',
          'template-rules-hint':
              'Both input fields support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the message metadata.',
          'originator-customer-desc': 'Use customer of incoming message originator as new originator.',
          'originator-tenant-desc': 'Use current tenant as new originator.',
          'originator-related-entity-desc': 'Use related entity as new originator. Lookup based on configured relation type and direction.',
          'originator-alarm-originator-desc': 'Use alarm originator as new originator. Only if incoming message originator is alarm entity.',
          'originator-entity-by-name-pattern-desc': 'Use entity fetched from DB as new originator. Lookup based on entity type and specified name pattern.',
          'email-from-template-hint': 'Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'recipients-block-main-hint': 'Comma-separated address list. All input fields support templatization. Use $[messageKey] to extract value from the message and ${metadataKey} to extract value from the metadata.',
          'forward-msg-default-rule-chain': 'Forward message to the originator\'s default rule chain',
          'forward-msg-default-rule-chain-tooltip': 'If enabled, message will be forwarded to the originator\'s default rule chain, or rule chain from configuration, if originator has no default rule chain defined in the entity profile.',
          'exclude-zero-deltas' : 'Exclude zero deltas from outbound message',
          'exclude-zero-deltas-hint' : 'If enabled, the "{{outputValueKey}}" output key will be added to the outbound message if its value is not zero.',
          'exclude-zero-deltas-time-difference-hint' : 'If enabled, the "{{outputValueKey}}" and "{{periodValueKey}}" output keys will be added to the outbound message only if the "{{outputValueKey}}" value is not zero.',
          'search-direction-from': 'From originator to target entity',
          'search-direction-to': 'From target entity to originator',
          'del-relation-direction-from': 'From originator',
          'del-relation-direction-to': 'To originator',
          'target-entity': 'Target entity',
          'function-configuration': 'Function configuration',
          'function-name': 'Function name',
          'function-name-required': 'Function name is required.',
          'qualifier': 'Qualifier',
          'qualifier-hint': 'If the qualifier is not specified, the default qualifier "$LATEST" will be used.',
          'aws-credentials': 'AWS Credentials',
          'connection-timeout': 'Connection timeout',
          'connection-timeout-required': 'Connection timeout is required.',
          'connection-timeout-min': 'Min connection timeout is 0.',
          'connection-timeout-hint': 'The amount of time to wait in seconds when initially establishing a connection before giving up and timing out. A value of 0 means infinity, and is not recommended.',
          'request-timeout': 'Request timeout',
          'request-timeout-required': 'Request timeout is required',
          'request-timeout-min': 'Min request timeout is 0',
          'request-timeout-hint': 'The amount of time to wait in seconds for the request to complete before giving up and timing out. A value of 0 means infinity, and is not recommended.',
          'tell-failure-aws-lambda': 'Tell Failure if AWS Lambda function execution raises exception',
          'tell-failure-aws-lambda-hint': 'Rule node forces failure of message processing if AWS Lambda function execution raises exception.',
        },
        'key-val': {
          key: 'Key',
          value: 'Value',
          'see-examples': 'See examples.',
          'remove-entry': 'Remove entry',
          'remove-mapping-entry': 'Remove mapping entry',
          'add-mapping-entry': 'Add mapping',
          'add-entry': 'Add entry',
          'copy-key-values-from': 'Copy key-values from',
          'delete-key-values': 'Delete key-values',
          'delete-key-values-from': 'Delete key-values from',
          'at-least-one-key-error': 'At least one key should be selected.',
          'unique-key-value-pair-error': '\'{{keyText}}\' must be different from the \'{{valText}}\'!',
        },
        'mail-body-type': {
          'plain-text': 'Plain text',
          html: 'HTML',
          dynamic: 'Dynamic',
          'use-body-type-template': 'Use body type template',
          'plain-text-description':
              'Simple, unformatted text with no special styling or formating.',
          'html-text-description':
              'Allows you to use HTML tags for formatting, links and images in your mai body.',
          'dynamic-text-description':
              'Allows to use Plain Text or HTML body type dynamically based on templatization feature.',
          'after-template-evaluation-hint': 'After template evaluation value should be true for HTML, and false for Plain text.'
        }
      }
    };
    translate.setTranslation('en_US', enUS, true);
}
